# 列表的创建
a = [10,20,30,40]
b = [10,20,"郝健成",True,1.1]
c = [] # 定义了一个空列表
d = list() # 通过list()方法创建空列表
e = list(range(10)) # 0~9
# list = [] # 这样子声明对象是错误的，不要以关键字命名
"""print(a)
print(b)
print(c)
print(d)
print(e) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"""
# 通过推导式生成列表
"""nums = [i for i in range(10)]
print(nums)"""

# 如果是正常写列表需要三行
"""nums_1 = [] # 用来收集元素
for i in range(10):
    nums_1.append(i) # 在nums_1列表后方追加元素
print(nums_1) # 最后打印下这个列表所有内容"""

# 列表的内置方法
nums = [10,20,30,40] # 定义一个空列表
# print(nums)
# 末尾追加元素
"""nums.append("郝健成")
nums.append("琳姐")
print(nums)"""
# 指定索引位置新增
"""nums.insert(0,"郝健成")
nums.insert(0,"王琳琳")
nums.insert(1,"丁莹")
print(nums) # ["王琳琳","丁莹","郝健成"]"""
# 删除具体的值
"""print(nums)
result = nums.remove(40) # 用remove删除方法，返回值是None，表示没有返回值
print(nums)
print(result)"""
# 根据索引位置删除元素
"""result = nums.pop(1) # 索引1的位置：20
print(nums) # [10,30,40]
print(result) # 使用pop删除是有返回值的，返回的是被删除掉的元素"""
# 根据del方法删除
"""del nums[0]  # python的内置方法，并不是list内置方法
print(nums)"""
# 修改列表元素内容
"""print(nums[0])
nums[0] = "郝健成plus"
print(nums)"""
# 查看列表内容
student = ["郝健成","郝健成1号","好健康","美年大健康","健康","成长"]
# print(student)
# 切片访问内容
#从左开始        0       1         2          3      4     5
#从右开始      -6         -5         -4      -3    -2      -1
# print(student)
"""print(student[1:3]) # 我想拿出 郝健成1号，好健康
print(student[2:5]) # 我想拿出 "好健康","美年大健康","健康"
print(student[1:5]) # 我想拿出 "郝健成1号","好健康","美年大健康","健康"
print(student[1:]) # 我想拿出 "郝健成1号","好健康","美年大健康","健康","成长"
print(student[::-1])# 倒序返回"""
# 遍历访问list对象，用for循环
"""for i in student:
    # 每一次遍历的i就是对应列表元素
    # 第一次的i：郝健成
    # 第二次的i：郝健成1号
    # 第三次的i：好健康
    # 第四次的i：美年大健康
    # 第五次的i：健康
    # 第六五的i：成长
    print(i)"""
# 遍历访问list对象，用for循环通过索引方式，结合len方法获取长度
"""print(len(student)) # 6
for i in range(len(student)):# range(6) 循环6次，每次从0开始到5结束
    # 每一次的i就是student索引值
    # 第一次循环：# student[0]
    # 第二次循环：# student[1]
    # 第三次循环：# student[2]
    # 第四次循环：# student[3]
    # 第五次循环：# student[4]
    # 第六次循环：# student[5]
    print(student[i])"""
# 遍历访问list对象，使用while循环
"""num = 0
while num<len(student): # 6<6? 不小于，所以没有第七次的循环
    # 第一次循环：num是0
    # 第二次循环：num是1
    # 第三次循环：num是2
    # 第四次循环：num是3
    # 第五次循环：num是4
    # 第六次循环：num是5
    print(student[num])
    # student[0]
    # student[1]
    # student[2]
    # student[3]
    # student[4]
    # student[5]
    num+=1"""

# 列表推导式案例
# 创建一个10以内的偶数列表
"""nums_ou = [i for i in range(10) if i%2==0]
print(nums_ou)"""
# 相当于下面的这个列表
"""nums1 = []
for i in range(10):
    if i%2==0:
        nums1.append(i)
print(nums1)"""
# 创建一个元素
"""nums2 = [(x,y) for x in range(5,10) for y in range(10,20)]
print(nums2)"""
# 相当于下面的这个列表
"""nums2_1 = []
for x in range(5,10):
    # 第一次循环，x是5
    # 第二次循环，x是6
    for y in range(10,20):
        # 第一次循环x是5的情况下：
        # y：10
        # y：11
        # y：12
        # y：13
        # y：14
        # y：15
        # y：16
        # y：17
        # y：18
        # y：19
        #第二次循环：x是6
        # y：10
        # y：11
        # y：12
        # y：13
        # y：..
        nums2_1.append((x,y))
        # x第一次的时候，分别就是：（5,10）,(5,11),(5,12),(5,13),(5,14),(5,15),(5,16),(5,17),(5,18),(5,19)
        # x第二次的时候，分别就是：（6,10）,(6,11),(6,12),(6,13),(6,14),(6,15),(6,16),(6,17),(6,18),(6,19)
print(nums2_1)"""
# 列表推导式
ts_file = ['2.ts','3.ts','4.ts','5.ts']
# 变成字符串的数字
"""s1 = [i.replace('.ts',"")  for i in ts_file]
print(s1)"""
# 变成整数
"""s2 = [int(i.replace('.ts',""))  for i in ts_file]
print(s2)"""
# 对生产整数的列表进行排序
"""l1 = [99,109,65,12,555]
print(sorted(l1,reverse=True)) # reverse默认值是False，升序；如果是True就是降序
print(sorted(l1)) # [12, 65, 99, 109, 555]，默认是升序排序
print(l1) # 但是原来的列表不会变的"""
"""nums_2 = sorted([int(i.replace('.ts', "")) for i in ts_file]) # 进行升序
print(nums_2) # [2,3,4,5]"""
# reversed：倒序方法
"""l2 = [99,109,65,12,555]
print(reversed(l2)) # 直接返回的是迭代器对象地址
print(list(reversed(l2))) # 如果想要看倒序的列表内容，需要强制转换成列表对象才可以
print(l2[::-1]) # 上面的reversed方法等同于这个"""

# 列表内部元素清空
l3 = [10,20,30]
"""del l3 # 直接把列表删除掉了
print(l3) # 报错了 not defined"""
"""l3.clear() # 清空列表所有元素，但是列表还在
print(l3)"""

# 列表统计元素出现的次数
list_obj = [10,10,20,20,33,44,55,66,11,223,44]
"""print(list_obj.count(10)) # count里面传递的是要看哪个出现几次
print(list_obj.count(33))  # 33只出现一次：1"""
# list_obj.append(100)
# print(list_obj)

# 判断元素是否存在于列表内
"""if "郝健成" in list_obj:
    print("郝健成在列表里")
else:
    print("郝健成不在")"""
"""if 10 in list_obj:
    print("列表里有10这个元素")
else:
    print("列表里没有10这个元素")"""
# 列表相求最大值
"""print(max(list_obj)) # 223
# 列表相求最小值
print(min(list_obj)) # 10
# 列表求和
print(sum(list_obj)) # 10+10+20+20+33+44+55+66+11+223+44"""

# 列表总结：
"""
因为列表可以进行增删改，所以列表是可变的数据类型

像是int类型整数，是一个常量，常量都是不可变的数据类型

昨天学过的str字符串，也是不可变的数据类型（不可以改变内部成员）
"""
# 从使用上来看，可变不可变的区别
"""str_obj = "郝健成"
str_obj[0] = "张"
print(str_obj) # str 不可改变 TypeError: 'str' object does not support item assignment"""
"""nums_4 = [10,20,30]
nums_4[0] = "郝健成"
print(nums_4)"""
# 从底层来看，可变和不可变的区别
# 不可变的数据类型，两个变量值相同，占用的地址空间也是一样的
#【1】 int类型
"""a1 = 10
b1 = 10
print(id(a1)) # id是用来查看变量地址值的
print(id(b1))"""
# 【2】 str类型
"""a_str = "郝健成1号"
b_str = "郝健成1号"
print(id(a_str))
print(id(b_str))"""
# 可变的数据类型，即使变量值相同，地址空间也不一样
"""a_list = [10,20,30]
b_list = [10,20,30]
print(id(a_list))
print(id(b_list))"""

# 列表浅复制 ，复制出来的id地址值是一样的
"""x = [100,200,300]
y = x  # 声明了一个y变量，通过x赋值的
x[0] = 1 # x = [1,200,300]
print(y)
print(id(x),id(y))"""

# 复制一个新的列表
"""b_list = x.copy() # 通过x列表复制一个列表出来
print(b_list) # [100,200,300]
print(id(x),id(b_list)) # 2354974657152 2354974657280"""

# 浅拷贝
import copy # import 可以到导入模块，用的copy模块
"""bb_list = x.copy() # 是一样的
aa_list = copy.copy(x) # 拷贝的是x列表
print(aa_list) # [100,200,300]
print(id(aa_list),id(x))"""
"""words = ['hello','good',[100,200,300],'yes','hi','ok'] # 源列表
words1 = copy.copy(words)  # 拷贝的列表
words1[2][0] = 1 # 改变的是拷贝的列表
print(words) # 原列表
print(words1) # 通过浅拷贝出来的列表"""

# 深拷贝
"""words = ['hello','good',[100,200,300],'yes','hi','ok']
words2 = copy.deepcopy(words) # 通过words深拷贝出来一个新列表
words2[2][0] = 1 #  words2[2] ：[100,200,300] [0]：100
print(words) # 原列表
print(words2) # 深拷贝的列表"""

# 综合案例一：
# 嵌套循环打印二维列表所有的数据
a_list1  = [["龙仔一",18,30000,"武汉"],["龙仔二",19,20000,"武汉"],["龙小一",20,10000,"武汉"]]
"""for i in range(len(a_list1)):# 3，
    # 第一次循环：0
    # 第二次循环：1
    # 第三次循环：2
    for j in range(len(a_list1[i])):
        # 当i是0的时候
        # j开始遍历：j第一次：["龙仔一",18,30000,"武汉"]，长度是4
        # j第一次循环："龙仔一"
        # j第二次循环：18
        # j第三次循环：30000
        # j第四次循环："武汉"
        print(a_list1[i][j])"""

# 案例二
# 一个学校,有三个办公室,现在有10位老师等待工位的分配,请编写程序,完成随机的分配

teachers = ['A','B','C','D','E','F','G','H','I','J'] # 所有的老师
rooms = [[],[],[]] # 所有的教室
import random
# import random # 必须要导入这个模块才可以使用random，导入下面的所有方法
# from random import randint # 导入这个方法以后，只可以使用randint，不需要使用random.来去引用了
# from random import *  # 导入random下的所有方法，不需要使用random.来去引用了

# print(choice([10, 999, 222, 3, 123, 123, 123]))
# print(randint(99,199))
# print(randint(0, 10)) # 只导入randint方法下，不需要用到random.来去引用了
# print(random.randint(0, 10)) # 从0开始~10结束，随机返回一个
# print(random.choice([10, 20, 30, 40])) # 在一个序列里随机返回一个
for tearcher in teachers:  # 定义tearcher为循环变量，访问teachers列表
    room = random.choice(rooms) # 每一次随机从rooms列表取出来一个，赋值给了room
    room.append(tearcher)  # 为每一个随机拿出来的room分配老师
# print(rooms) # [['A', 'C', 'D', 'G', 'I'], ['B', 'E', 'F', 'H', 'J'], []]

"""for 郝健成,room in enumerate(rooms):# 比如这里遍历的是rooms，rooms长度是三
    # 郝健成是枚举值，会根据遍历的长度来生成
    # 所以郝健成就会从0开始到2结束
    print(f"房间{郝健成+1}里一共有{len(room)}个老师分别是：")
    for i in room: # 再进一步遍历每一个教室下的老师
        print(i) # 打印输出每一个老师
    pass  # 占位，什么都不做"""

nums_list = [10,20,30]
for index,value in enumerate(nums_list): #  nums_list长度是3
    # index：3枚举值变量，它的范围跟随着nums_list长度来定
    #第一次循环index：0，value：10
    #第二次循环index：1，value：20
    #第三次循环index：2，value：30
    print(f"第{index+1}的内容为：{value}")





































